/**
 * 工具栏组件模块
 * 负责处理富文本格式化工具栏的交互和功能
 */

export class Toolbar {
    constructor(editorCore) {
        this.editorCore = editorCore;
        this.quill = editorCore.quill;
        this.toolbar = null;
        this.customButtons = new Map();
        
        this.init();
    }

    /**
     * 初始化工具栏
     */
    init() {
        this.setupToolbarConfig();
        this.bindEvents();
        this.addCustomButtons();
    }

    /**
     * 设置工具栏配置
     */
    setupToolbarConfig() {
        // 工具栏配置已在 EditorCore 中设置，这里不需要重复配置
        console.log('工具栏配置已在 EditorCore 中完成');
        
        // 获取已存在的工具栏实例
        if (this.quill) {
            this.toolbar = this.quill.getModule('toolbar');
        }
    }

    /**
     * 生成工具栏 HTML
     */
    generateToolbarHTML(options) {
        let html = '';
        
        options.forEach(group => {
            html += '<span class="ql-formats">';
            
            group.forEach(item => {
                if (typeof item === 'string') {
                    // 简单按钮
                    html += `<button class="ql-${item}" type="button"></button>`;
                } else if (typeof item === 'object') {
                    // 下拉选择器
                    const key = Object.keys(item)[0];
                    const values = item[key];
                    
                    if (Array.isArray(values)) {
                        html += `<select class="ql-${key}">`;
                        values.forEach(value => {
                            if (value === false) {
                                html += '<option selected></option>';
                            } else {
                                html += `<option value="${value}">${value}</option>`;
                            }
                        });
                        html += '</select>';
                    } else {
                        html += `<button class="ql-${key}" value="${values}" type="button"></button>`;
                    }
                }
            });
            
            html += '</span>';
        });
        
        return html;
    }

    /**
     * 绑定事件
     */
    bindEvents() {
        if (!this.quill) return;

        // 监听选择变化，更新工具栏状态
        this.quill.on('selection-change', (range) => {
            if (range) {
                this.updateToolbarState(range);
            }
        });

        // 监听文本变化 - 字数统计由EditorCore处理
        this.quill.on('text-change', () => {
            // 字数统计更新已移至EditorCore
        });

        // 键盘快捷键
        this.setupKeyboardShortcuts();
    }

    /**
     * 添加自定义按钮
     */
    addCustomButtons() {
        // 移除重复的字数统计按钮，字数统计已在状态栏显示
        // 暂时移除全屏和导出按钮，避免功能重复
    }

    /**
     * 添加自定义按钮
     */
    addCustomButton(id, title, handler) {
        const toolbar = document.querySelector('.ql-toolbar');
        if (!toolbar) return;

        // 创建按钮
        const button = document.createElement('button');
        button.className = `ql-${id} custom-button`;
        button.type = 'button';
        button.title = title;
        button.innerHTML = this.getButtonIcon(id);
        
        // 添加到工具栏
        const lastGroup = toolbar.querySelector('.ql-formats:last-child');
        if (lastGroup) {
            lastGroup.appendChild(button);
        } else {
            const newGroup = document.createElement('span');
            newGroup.className = 'ql-formats';
            newGroup.appendChild(button);
            toolbar.appendChild(newGroup);
        }

        // 绑定事件
        button.addEventListener('click', handler);
        
        // 存储引用
        this.customButtons.set(id, button);
    }

    /**
     * 获取按钮图标
     */
    getButtonIcon(id) {
        const icons = {
            // 自定义按钮图标映射（当前无自定义按钮）
        };
        return icons[id] || '🔧';
    }

    /**
     * 更新工具栏状态
     */
    updateToolbarState(range) {
        if (!this.quill || !range) return;

        const format = this.quill.getFormat(range);
        
        // 更新按钮状态
        const toolbar = document.querySelector('.ql-toolbar');
        if (!toolbar) return;

        // 清除所有活动状态
        toolbar.querySelectorAll('.ql-active').forEach(btn => {
            btn.classList.remove('ql-active');
        });

        // 设置当前格式的按钮为活动状态
        Object.keys(format).forEach(key => {
            const button = toolbar.querySelector(`.ql-${key}`);
            if (button) {
                button.classList.add('ql-active');
            }
        });
    }

    /**
     * 设置键盘快捷键
     */
    setupKeyboardShortcuts() {
        const shortcuts = {
            'Ctrl+B': () => this.toggleFormat('bold'),
            'Ctrl+I': () => this.toggleFormat('italic'),
            'Ctrl+U': () => this.toggleFormat('underline'),
            'Ctrl+Shift+S': () => this.toggleFormat('strike'),
            'Ctrl+Shift+L': () => this.toggleFormat('list', 'bullet'),
            'Ctrl+Shift+O': () => this.toggleFormat('list', 'ordered'),
            'Ctrl+Shift+Q': () => this.toggleFormat('blockquote'),
            'Ctrl+Shift+C': () => this.toggleFormat('code-block'),
            'Ctrl+K': () => this.insertLink()
            // F11全屏快捷键已移除
        };

        document.addEventListener('keydown', (e) => {
            const key = this.getKeyCombo(e);
            if (shortcuts[key]) {
                e.preventDefault();
                shortcuts[key]();
            }
        });
    }

    /**
     * 获取按键组合
     */
    getKeyCombo(e) {
        const parts = [];
        if (e.ctrlKey || e.metaKey) parts.push('Ctrl');
        if (e.shiftKey) parts.push('Shift');
        if (e.altKey) parts.push('Alt');
        
        if (e.key === 'F11') {
            parts.push('F11');
        } else if (e.key.length === 1) {
            parts.push(e.key.toUpperCase());
        } else {
            parts.push(e.key);
        }
        
        return parts.join('+');
    }

    /**
     * 切换格式
     */
    toggleFormat(format, value = true) {
        if (!this.quill) return;

        const range = this.quill.getSelection();
        if (!range) return;

        const currentFormat = this.quill.getFormat(range);
        const isActive = currentFormat[format];

        if (isActive) {
            this.quill.format(format, false);
        } else {
            this.quill.format(format, value);
        }
    }

    /**
     * 插入链接
     */
    insertLink() {
        if (!this.quill) return;

        const range = this.quill.getSelection();
        if (!range) return;

        const url = prompt('请输入链接地址:');
        if (url) {
            this.quill.format('link', url);
        }
    }

    // showWordCount方法已移除，字数统计功能统一在状态栏显示

    // updateWordCount方法已移至EditorCore，避免重复实现

    // toggleFullScreen和exportDocument方法已移除，避免功能重复

    // performExport和convertToMarkdown方法已移除，导出功能由FileManager统一处理

    /**
     * 获取当前格式
     */
    getCurrentFormat() {
        if (!this.quill) return {};
        
        const range = this.quill.getSelection();
        return range ? this.quill.getFormat(range) : {};
    }

    /**
     * 应用格式
     */
    applyFormat(format, value) {
        if (!this.quill) return;
        
        const range = this.quill.getSelection();
        if (range) {
            this.quill.formatText(range.index, range.length, format, value);
        }
    }

    /**
     * 清除格式
     */
    clearFormat() {
        if (!this.quill) return;
        
        const range = this.quill.getSelection();
        if (range) {
            this.quill.removeFormat(range.index, range.length);
        }
    }

    /**
     * 销毁工具栏
     */
    destroy() {
        // 移除自定义按钮
        this.customButtons.forEach(button => {
            if (button.parentNode) {
                button.parentNode.removeChild(button);
            }
        });
        this.customButtons.clear();
        
        // 清理引用
        this.toolbar = null;
        this.quill = null;
        this.editorCore = null;
    }
}